package org.lisy.java.collection;

import java.util.Arrays;

/**
 * 数组操作
 * 
 * @author lishangyuan
 */
public class ArrayOperate {

	/**
	 * 数组就是同一种类型数据的集合，就是一个容器
	 * 数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素
	 * @param str
	 */
    public static void main(String[] str) {
    	/**
         * 格式：元素类型 [] 数组名 = new 元素类型[元素个数] 
         * 定义一个可以存储3个整数的容器
         */
        int[] arr = new int[3];
        
        // 数组还有另外一种格式   静态初始化
		int[] arr1 = new int[] { 3, 6, 8, 74, 99, 12 };
		int[] arr2 = { 3, 6, 8, 74, 99, 12 };
        
        /**
         * 数组的扩容 (创建了一个新的数组并将源数组数据复制过去)
         * arr.length+1表示扩容一个 
         * arr.length-1表示缩容一个
         */
        // 扩容一个, 默认值0
        arr = Arrays.copyOf(arr, arr.length + 1);
        printArray(arr);
        // 缩容一个
        arr = Arrays.copyOf(arr, arr.length - 1);
        printArray(arr);
        
        /**
         * 数组的复制
         */
        // 方式一，不灵活、效率低
        int[] a1 = Arrays.copyOf(arr1, 4); // arr1:源数组,a1:目标数组,4:目标数组的长度 
        printArray(a1);
        
	    // 方式二 灵活、效率高
        int[] a2 = new int[6];
        // arr1:源数组,1:源数组的起始下标,a2:目标数组,0:目标数组的起始下标,4:要复制的元素的个数
        System.arraycopy(arr1, 1, a2, 0, 4); 
        // 目标数组有6个元素，只复制了4个过来，剩余的为默认值0
        printArray(a2);
        
        /**
         * 数组遍历
         */
        for (int i = 0; i < arr2.length; i++) {
			System.out.println("遍历数组(正序)：" + arr2[i]);
		}
        for (int i = arr2.length - 1; i >= 0 ; i--) {
			System.out.println("遍历数组(倒序)：" + arr2[i]);
		}
        
        // 调用打印数组方法
        printArray(arr1);
        
        /**
         * 获取最大值
         */
        int max = arr2[0];
        int min = arr2[0];
        for (int i = 1; i < arr2.length; i++) {
            if (arr2[i] > max) {
                max = arr2[i];
            }
        }
        System.out.println("最大值：" + max);

        /**
         * 获取最小值
         */
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] < min) {
                min = arr2[i];
            }
        }
        System.out.println("最小值：" + min);
        
        /**
         * 数组排序
         */
        
        // 升序方法sort
        Arrays.sort(arr2);
        printArray(arr2);
        
        // 选择排序法
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1.length; j++) {
                if (arr1[i] > arr1[j]) {
                    int temp = arr1[i];
                    arr1[i] = arr1[j];
                    arr1[j] = temp;
                }
            }
        }
        printArray(arr1);
        
        // 冒泡排序法
		for (int i = 0; i < arr2.length - 1; i++) {
			// 每一次比较的元素-1，避免角标越界
			for (int j = 0; j < arr2.length - i - 1; j++) {
				if (arr2[j] < arr2[j + 1]) {
					int temp = arr2[j];
					arr2[j] = arr2[j + 1];
					arr2[j + 1] = temp;
				}
			}
		}
        printArray(arr2);
        
        // 插入排序法
        for(int i = 1; i < arr2.length; i++){
			int temp = arr2[i];
			int j;
			for(j = i - 1; j >= 0 && temp < arr2[j]; j--){
				arr2[j+1] = arr2[j];
			}
			arr2[j+1] = temp;
		}
        printArray(arr2);
        
        /**
         * 二维数组 定义
         */
        // int [] x, y [];  x是一维 y是二维
		// int [] [] arr01 = new int [3] [2] ; arr01是二维
        int[][] arr02 = { { 4, 6, 8 }, { 99, 22, 88 }, { 74, 36, 1 } };
        
        // 求和
        int num = 0;
        for (int i = 0; i < arr02.length; i++) {
            for (int j = 0; j < arr02[i].length; j++) {
                num = num + arr02[i][j];
            }
        }
        System.out.println("num:" + num);
    }
    
    /**
     * 打印数组中的元素用逗号隔开
     * @param array
     */
	public static void printArray(int[] array) {
		for (int i = 0; i < array.length; i++) {
			// 最后一个
			if (i == array.length - 1) {
				System.out.println(array[i]);
			} else {
				System.out.print(array[i] + ",");
			}
		}
	}

}
